package com.rui.study.algorithm.T_thread_pool;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * @program: study
 * @description:
 * @author: Yaowr
 * @create: 2019-03-21 16:42
 **/
public class TestQuque {

    public static void test_queue() {
        SynchronousQueue queue = new SynchronousQueue();
        /**
         * 生产者1--put：放入队列，一直等到其它线程来收取
         */
//        new Thread(()->{
//            for (;;) {
//                try {
//                    queue.put("A");
//                    System.out.println("生产者1--put: SUCCEED");
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//        }).start();

        /**
         * 生产者2--offer(wait)：放入队列，在指定的时间内被其它线程收取则返回true，没有线程来收取，则返回false
         */
        new Thread(()-> {
            for (;;) {
                try {
                    System.out.println("生产者2--offer(wait): " + (queue.offer("B", 500, TimeUnit.MILLISECONDS)?"SUCCEED":"FAILED"));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        /**
         * 生产者3--offer：放入队列，被其它线程收取则返回true，没有线程来收取，则返回false
         */
//        new Thread(()-> {
//            RateLimiter rateLimiter = RateLimiter.create(4);
//            for (;;) {
//                rateLimiter.acquire();
//                System.out.println("生产者3--offer: " + (queue.offer("C")?"SUCCEED":"FAILED"));
//            }
//        }).start();

        /**------------------------------------------------
         |                                                |
         --------------------------------------------------*/
//

        /**
         * 消费者1--take：收取队列头部元素，一直等到其它线程放入队列
         */
//        new Thread(()-> {
//            for (;;) {
//                try {
//                    System.out.println("消费者1--take: " + queue.take());
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//        }).start();

        /**
         * 消费者2--poll(wait)：收取队列头部元素，在指定时间内，有其它线程放入队列，则收取成功返回头部元素，否则收取失败，返回null
         */
        new Thread(()-> {
            for (;;) {
                try {
                    System.out.println("消费者2--poll(wait): " + queue.poll(500, TimeUnit.MILLISECONDS));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        /**
         * 消费者3--poll()：收取队列头部元素，有其它线程放入队列，则收取成功返回头部元素，否则收取失败，返回null
         */
//        new Thread(()-> {
//            RateLimiter rateLimiter = RateLimiter.create(100);
//            for (;;) {
//                rateLimiter.acquire();
//                System.out.println("消费者3--poll(): " + queue.poll());
//            }
//        }).start();

    }

    public static void test_thread_interrupted() {
        Thread t = new Thread(()->{
            for (;;) {
                try {
                    Thread.sleep(186000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.interrupt();
    }

    public static void main(String[] args) {
        test_queue();
//        test_thread_interrupted();
    }
}
